components/calendar-token-list.tsx (1)

65-67: Consider adding error feedback for the toggle action.

The handleToggleActive function doesn't handle potential failures from updateToken. While the hook likely shows a toast on error internally, the UI state (e.g., dropdown menu) might benefit from knowing if the action succeeded.

For comparison, handleDelete (lines 69-77) checks the return value and only updates local state on success.

💡 Optional: Add success handling for consistency

 const handleToggleActive = async (token: CalendarAccessToken) => {
-   await updateToken(token.id, { isActive: !token.isActive });
+   const success = await updateToken(token.id, { isActive: !token.isActive });
+   // Handle success/failure if needed for UI feedback
 };

lib/query-keys.ts (1)

40-45: Consider stronger typing for the filters parameters.

The filters?: object type is permissive. If specific filter shapes are known, defining interfaces would improve type safety and enable IDE autocompletion.

💡 Optional: Define filter interfaces for better type safety

// Example filter interfaces (adjust based on actual usage)
interface UserFilters {
  search?: string;
  status?: "active" | "inactive";
  role?: string;
}

interface CalendarFilters {
  search?: string;
  ownerId?: string;
}

// Then use them:
users: (filters?: UserFilters) => ["admin", "users", filters] as const,
calendars: (filters?: CalendarFilters) => ["admin", "calendars", filters] as const,

hooks/useCompareData.ts (3)

15-43: Inconsistent error handling between fetch and mutation functions.

The fetch functions (fetchShiftsApi, fetchNotesApi, fetchExternalSyncsApi, fetchPresetsApi) silently return empty arrays on failure, while mutation functions throw errors. This inconsistency can mask real API failures in compare mode - users won't know if data failed to load vs. genuinely empty.

Consider throwing errors and letting React Query handle retries/error states:

♻️ Suggested approach for consistent error handling

 async function fetchShiftsApi(
   calendarId: string
 ): Promise<ShiftWithCalendar[]> {
   const response = await fetch(`/api/shifts?calendarId=${calendarId}`);
-  if (!response.ok) return [];
+  if (!response.ok) {
+    throw new Error("Failed to fetch shifts");
+  }
   const data = await response.json();
   return data.map(normalizeShift);
 }

Apply similar changes to other fetch functions. Then handle the error state in the hook's return value if needed.

---

129-141: Unstable memoization dependencies cause unnecessary recomputation.

The intermediate arrays (shiftsDataArray, etc.) are created fresh on every render via .map(), causing the useMemo hooks to recompute even when the underlying query data hasn't changed. This defeats the purpose of memoization.

♻️ Consider using useMemo for the intermediate arrays

-  const shiftsDataArray = shiftsQueries.map((q) => q.data);
-  const notesDataArray = notesQueries.map((q) => q.data);
-  const externalSyncsDataArray = externalSyncsQueries.map((q) => q.data);
-  const presetsDataArray = presetsQueries.map((q) => q.data);
-  const presetsLoadingArray = presetsQueries.map((q) => q.isLoading);
+  const shiftsDataArray = useMemo(
+    () => shiftsQueries.map((q) => q.data),
+    [shiftsQueries]
+  );
+  // Apply similar pattern to other arrays

Alternatively, combine the map-building logic into single useMemo calls that depend directly on the query results.

---

182-215: Good mutation structure, but consider adding optimistic updates.

The mutations correctly invalidate cache on success. However, given the PR objective mentions optimistic updates, consider implementing them here for a better UX during shift toggle operations. Based on learnings, optimistic updates should use temporary IDs and rollback on error.

hooks/useExternalSync.ts (2)

61-76: Non-null assertion on potentially null value.

The selectedCalendar! assertion is safe here because enabled: !!selectedCalendar prevents execution when null. However, this pattern is fragile - if someone removes the enabled check, it would cause runtime issues.

♻️ Cleaner pattern to avoid non-null assertions

   const { data: externalSyncs = [], isLoading: syncsLoading } = useQuery({
-    queryKey: queryKeys.externalSyncs.byCalendar(selectedCalendar!),
-    queryFn: () => fetchExternalSyncsApi(selectedCalendar!),
+    queryKey: queryKeys.externalSyncs.byCalendar(selectedCalendar ?? ""),
+    queryFn: () => fetchExternalSyncsApi(selectedCalendar!),
     enabled: !!selectedCalendar,
     refetchInterval: 5000,
     refetchIntervalInBackground: true,
   });

Or extract the calendar ID check into the queryFn with an early return.

---

65-76: Consider disabling background polling for resource efficiency.

refetchIntervalInBackground: true continues polling even when the browser tab is hidden. For sync status that doesn't require immediate attention when the user isn't looking, consider removing this flag to reduce server load.

app/api/activity-logs/route.ts (1)

65-68: Redundant severity filtering for audit logs.

Severity is filtered at the database level for audit logs (line 67) and again post-merge (line 172). While this works correctly, the post-merge filter is only necessary for sync logs (which derive severity from status). Consider skipping the post-merge filter when the type isn't "sync":

♻️ Suggested optimization

     // 3. Apply severity filter after merging (sync logs derive severity from status)
     // ============================================
     let filteredLogs = allLogs;
-    if (severity) {
+    // Only apply post-merge severity filter if sync logs are included
+    // (audit logs are already filtered at DB level)
+    if (severity && (!type || type === "sync")) {
       filteredLogs = filteredLogs.filter((log) => log.severity === severity);
     }

Also applies to: 170-173

hooks/useNotes.ts (2)

89-102: Consider removing unnecessary body from DELETE request.

The DELETE request sends an empty JSON body which is unusual. While not incorrect, DELETE requests typically don't require a body.

🔧 Suggested simplification

 async function deleteNoteApi(id: string): Promise<void> {
   const response = await fetch(`/api/notes/${id}`, {
     method: "DELETE",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({}),
   });
 
   if (!response.ok) {
     const errorText = await response.text();
     throw new Error(
       `Failed to delete note: ${response.status} ${response.statusText} - ${errorText}`
     );
   }
 }

---

104-115: Consider consolidating identical context types.

The three context interfaces are identical. While this works, consider using a single type alias to reduce duplication.

🔧 Optional consolidation

-// Context types for optimistic updates
-interface CreateNoteContext {
-  previous: CalendarNote[] | undefined;
-}
-
-interface UpdateNoteContext {
-  previous: CalendarNote[] | undefined;
-}
-
-interface DeleteNoteContext {
-  previous: CalendarNote[] | undefined;
-}
+// Context type for optimistic updates
+interface MutationContext {
+  previous: CalendarNote[] | undefined;
+}

app/admin/users/page.tsx (1)

55-55: Consider pagination for scalability.

The limit: 1000 effectively disables pagination, fetching all users at once. For admin panels with many users, this could impact performance. Consider implementing proper pagination UI or at least documenting this as a known limitation.

components/admin/audit-log-delete-dialog.tsx (1)

17-34: Avoid redundant polling in the dialog.
useAdminAuditLogs() performs a polling query every 5s; instantiating it here can trigger extra network traffic (and potentially a different default filter/pagination) even though the dialog only needs delete mutations. Consider passing delete handlers from the parent or exposing an action‑only hook (e.g., useAdminAuditLogActions) that surfaces mutation pending state.

hooks/useAdminCalendars.ts (3)

89-94: Unused parameter t in fetchCalendarsApi.

The t parameter is accepted but never used, with an eslint-disable comment suppressing the warning. Either remove the parameter or utilize it for error message translation if that was the intent.

Suggested fix

 async function fetchCalendarsApi(
   filters: CalendarFilters | undefined,
-  sort: CalendarSort | undefined,
-  // eslint-disable-next-line `@typescript-eslint/no-unused-vars`
-  t: ReturnType<typeof useTranslations>
+  sort: CalendarSort | undefined
 ): Promise<CalendarsListResponse> {

And update the caller at line 292:

-    queryFn: () => fetchCalendarsApi(filters, sort, t),
+    queryFn: () => fetchCalendarsApi(filters, sort),

---

341-344: Inconsistent query key usage in cache invalidation.

onSettled uses a hardcoded ["admin", "calendars"] array alongside queryKeys.admin.stats. For consistency and maintainability, consider using the query key factory throughout, or use a broader invalidation pattern consistently across all mutations.

The hardcoded array does work as a prefix match for invalidation, but mixing patterns reduces clarity.

---

358-369: orphanedCount not updated in delete optimistic update.

When deleting a calendar, the optimistic update decrements total but doesn't adjust orphanedCount. If the deleted calendar was orphaned, the count will be momentarily incorrect until the query refetches.

Suggested fix

       queryClient.setQueryData(
         queryKeys.admin.calendars({ filters, sort }),
         (old: CalendarsListResponse | undefined) => {
           if (!old) return old;
+          const deletedCalendar = old.calendars.find((cal) => cal.id === calendarId);
+          const wasOrphaned = deletedCalendar && !deletedCalendar.ownerId;
           return {
             ...old,
             calendars: old.calendars.filter((cal) => cal.id !== calendarId),
             total: old.total - 1,
+            orphanedCount: wasOrphaned ? old.orphanedCount - 1 : old.orphanedCount,
           };
         }
       );

hooks/usePresets.ts (1)

67-78: DELETE request with empty JSON body is unusual.

The deletePresetApi sends a DELETE request with body: JSON.stringify({}). While not incorrect, DELETE requests typically don't include a body. Consider removing the body if the API doesn't require it.

Suggested fix

 async function deletePresetApi(presetId: string): Promise<void> {
   const response = await fetch(`/api/presets/${presetId}`, {
     method: "DELETE",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({}),
   });

app/profile/activity/page.tsx (1)

97-103: Unnecessary limit in useMemo dependency array.

limit is a constant (line 65) and will never change. Including it in the dependency array is harmless but unnecessary.

   const pagination = useMemo(
     () => ({
       limit,
       offset: page * limit,
     }),
-    [page, limit]
+    [page]
   );

hooks/useAdminAuditLogs.ts (1)

60-95: Localize fetch errors and drop the unused‑var suppression.

Hardcoded errors bypass i18n and the t arg is currently unused.
As per coding guidelines, localize all user‑facing strings.

🌐 Suggested i18n update

 async function fetchAuditLogsApi(
   filters: AuditLogFilters,
   sort: AuditLogSort,
   pagination: AuditLogPagination,
-  // eslint-disable-next-line `@typescript-eslint/no-unused-vars`
   t: ReturnType<typeof useTranslations>
 ): Promise<AuditLogsResponse> {
@@
   if (!response.ok) {
     if (response.status === 403) {
-      throw new Error("Access denied");
+      throw new Error(t("admin.accessDenied"));
     }
-    throw new Error("Failed to fetch audit logs");
+    throw new Error(t("common.fetchError", { item: t("admin.auditLogs") }));
   }

hooks/useActivityLogs.ts (1)

46-101: Localize activity‑log messages (fetch/clear/success).

Hardcoded strings bypass i18n; please use translation keys instead.
As per coding guidelines, all user‑facing strings should go through t().

🌐 Suggested i18n update (adjust keys to match your locale files)

 async function fetchActivityLogsApi(
   filters: ActivityLogsFilters,
-  pagination: ActivityLogsPagination
+  pagination: ActivityLogsPagination,
+  t: ReturnType<typeof useTranslations>
 ): Promise<ActivityLogsResponse> {
@@
   if (!response.ok) {
-    throw new Error("Failed to fetch activity logs");
+    throw new Error(
+      t("common.fetchError", { item: t("activityLogs.title") })
+    );
   }
@@
 async function clearLogsApi(
   t: ReturnType<typeof useTranslations>
 ): Promise<void> {
@@
   if (!response.ok) {
-    throw new Error(t("common.deleteError", { item: "Activity logs" }));
+    throw new Error(
+      t("common.deleteError", { item: t("activityLogs.title") })
+    );
   }
 }
@@
   } = useQuery({
     queryKey: queryKeys.activityLogs({ filters, pagination }),
-    queryFn: () => fetchActivityLogsApi(filters, pagination),
+    queryFn: () => fetchActivityLogsApi(filters, pagination, t),
     refetchInterval: REFETCH_INTERVAL,
     refetchIntervalInBackground: true, // Continue polling in background
   });
@@
     onSuccess: () => {
-      toast.success("Activity logs cleared");
+      toast.success(t("activityLogs.cleared"));
       queryClient.invalidateQueries({ queryKey: ["activity-logs"] });
     },
     onError: (err) => {
       toast.error(
-        err instanceof Error ? err.message : "Failed to clear activity logs"
+        err instanceof Error
+          ? err.message
+          : t("common.deleteError", { item: t("activityLogs.title") })
       );
     },
   });

Also applies to: 140-150

hooks/useExternalSync.ts (1)

12-23: Consider extracting error details from API response.

The error handling discards potentially useful error information from the response body. Consider parsing the error response for more informative messages.

💡 Suggested improvement

 async function fetchExternalSyncsApi(
   calendarId: string
 ): Promise<ExternalSync[]> {
   const params = new URLSearchParams({ calendarId });
   const response = await fetch(`/api/external-syncs?${params}`);

   if (!response.ok) {
-    throw new Error("Failed to fetch external syncs");
+    const data = await response.json().catch(() => ({}));
+    throw new Error(data.error || "Failed to fetch external syncs");
   }

   return await response.json();
 }

hooks/useAdminCalendars.ts (2)

342-345: Inconsistent query key usage in cache invalidation.

onSettled uses a hardcoded array ["admin", "calendars"] instead of queryKeys.admin.calendars(...). While this works for prefix-based invalidation, it's inconsistent with the typed query keys used elsewhere and could drift if the key structure changes.

♻️ Use queryKeys for consistency

     onSettled: () => {
-      queryClient.invalidateQueries({ queryKey: ["admin", "calendars"] });
+      queryClient.invalidateQueries({ 
+        queryKey: queryKeys.admin.calendars({}),
+        exact: false 
+      });
       queryClient.invalidateQueries({ queryKey: queryKeys.admin.stats });
     },

Apply similar changes to deleteMutation, transferMutation, bulkDeleteMutation, and bulkTransferMutation at lines 387, 412, 460, and 487.

---

359-370: Optimistic update doesn't adjust orphanedCount.

When deleting a calendar, if the deleted calendar was orphaned (owner === null), orphanedCount should also be decremented for accurate optimistic UI. Currently it remains unchanged until the query refetches.

💡 Optional: More precise optimistic update

       queryClient.setQueryData(
         queryKeys.admin.calendars({ filters, sort }),
         (old: CalendarsListResponse | undefined) => {
           if (!old) return old;
+          const deletedCal = old.calendars.find((cal) => cal.id === calendarId);
+          const wasOrphaned = deletedCal && deletedCal.ownerId === null;
           return {
             ...old,
             calendars: old.calendars.filter((cal) => cal.id !== calendarId),
             total: old.total - 1,
+            orphanedCount: wasOrphaned ? old.orphanedCount - 1 : old.orphanedCount,
           };
         }
       );

components/external-sync-manage-sheet.tsx (1)

100-129: Query fetching is duplicated from useExternalSync hook.

This component duplicates the query logic from hooks/useExternalSync.ts. Consider whether useExternalSync could be extended to expose syncLogs directly, avoiding the duplication.

However, the current approach is acceptable since:

• The component needs direct access to syncLogsData for error computation
• The enabled: !!calendarId && open condition is specific to this dialog

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useSSEConnection` hook from `hooks/useSSEConnection.ts` for real-time sync connection management. The hook automatically handles reconnection, visibility changes, and triggers data refreshes.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*.{ts,tsx} : Implement data fetching hooks following the pattern: `useShifts`, `usePresets`, `useNotes`, `useCalendars` with accompanying action hooks like `useShiftActions`, `useNoteActions` for CRUD operations with optimistic updates.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : After any database mutation (create/update/delete), emit an SSE event using `eventEmitter.emit('calendar-change', {...})` with appropriate type and action to keep clients in sync.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to components/**/*sheet*.{tsx,ts} : Use the Sheet pattern (`components/ui/base-sheet.tsx`) for all forms with side panels, including unsaved changes confirmation via `useDirtyState` hook and consistent header/footer styling with gradient backgrounds.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useSSEConnection` hook from `hooks/useSSEConnection.ts` for real-time sync connection management. The hook automatically handles reconnection, visibility changes, and triggers data refreshes.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*.{ts,tsx} : Implement data fetching hooks following the pattern: `useShifts`, `usePresets`, `useNotes`, `useCalendars` with accompanying action hooks like `useShiftActions`, `useNoteActions` for CRUD operations with optimistic updates.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Respect `shift.syncedFromExternal` flag - synced shifts from external calendars cannot be edited or deleted by users. Check this flag before allowing shift mutations.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useCalendarPermission(calendarId)` hook to check UI permissions, which returns `canEdit`, `canDelete`, `canShare`, and `permission` level for displaying conditional UI elements.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/auth/**/*.ts : For Better Auth integration, use built-in methods for authentication operations (`login`, `logout`, `session management`, `OAuth`). Use custom code in `lib/auth/admin.ts` only for permission checks (`canEditUser`, `canDeleteUser`, `canBanUser`).

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*Actions.{ts,tsx} : Implement optimistic updates in action hooks by: generating temp ID (`temp-${Date.now()}`), adding item to state immediately, making API call, removing temp item on error with toast, replacing temp item on success.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : For auth-related configuration checks, use the convenience hook `useAuthFeatures()` from `hooks/useAuthFeatures.ts` to access `isAuthEnabled`, `allowRegistration`, `allowGuest`, and `providers` on the client side.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : After any database mutation (create/update/delete), emit an SSE event using `eventEmitter.emit('calendar-change', {...})` with appropriate type and action to keep clients in sync.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to lib/db/schema.ts : Database schema modifications must be made in `lib/db/schema.ts`. After changes, generate migrations with `npm run db:generate`, review SQL in `drizzle/` folder, then apply with `npm run db:migrate`.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/**/*.{tsx,ts} : All components under `app/` are Server Components by default unless marked with `"use client"`. Use `"use client"` directive only for interactive UI components.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use Better Auth's built-in client methods (`authClient.listSessions()`, `authClient.revokeOtherSessions()`) for client-side session management. Never implement custom session revocation logic.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to components/**/*.{tsx,ts} : Components in `/components` directory should be `"use client"` by default for interactive UI, and should use shadcn/ui patterns with Radix UI primitives and Lucide icons.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : All API routes must include `GET/POST/PUT/PATCH/DELETE` exports in `app/api/**` directory and follow the pattern: check permissions → perform database operation → emit SSE event.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: All user-facing strings must use the `t()` function from `next-intl` for translations. Never use hardcoded English strings in components or API responses.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : Use `getSessionUser(request.headers)` from `lib/auth/sessions.ts` to get current user in API routes. Use Better Auth's `authClient` methods on the client side for session management.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Use `getPublicConfig()` function from `lib/public-config.ts` in Server Components to access configuration. Use `usePublicConfig()` hook from `hooks/usePublicConfig.ts` in Client Components. Never use `process.env.NEXT_PUBLIC_*` directly.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{ts,tsx} : All React files must be in strict mode with TypeScript 5. No `any` types allowed. Import inferred types from Drizzle schema.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{ts,tsx} : Use Drizzle-inferred types from schema directly (no `any` types). TypeScript must remain in strict mode with proper type safety throughout the application.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to components/**/*dialog*.{tsx,ts} : Use the Dialog pattern (`components/ui/dialog.tsx` from shadcn/ui) for list views, confirmations, and read-only displays.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : For calendar permission hierarchy in SQL queries and permission checks, follow: `owner` (highest) > `admin` > `write` > `read` (lowest). Use `getUserAccessibleCalendars(userId)` to get all accessible calendars.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}

hooks/useCalendarSubscriptions.ts (2)

236-246: Stale closure issue addressed using cache lookup.

The onSuccess handler now correctly uses queryClient.getQueryData to fetch fresh cache data instead of relying on a stale availableCalendars closure. The lookup checks both arrays since the optimistic update moves the calendar to dismissed.

---

258-258: Type mismatch issue addressed.

The error is now correctly returned as errorMessage?.message (string) instead of the Error object, matching the expected string | null return type.

app/page.tsx (1)

675-676: Remove no‑op onPresetsChange props by making it optional.

There are still empty handlers passed into DialogManager. Consider making the prop optional and dropping these no‑ops to keep the API clean and consistent with React Query invalidation.

Also applies to: 763-764

components/admin/admin-header.tsx (1)

131-142: Approve with minor simplification suggestion.

The connection status indicator works correctly. Consider flattening the nested div structure—the title attribute can be applied directly to the indicator element:

🔧 Optional: Flatten nested divs

             {/* Connection Status Indicator */}
-            <div
-              title={isOnline ? t("sync.connected") : t("sync.disconnected")}
-            >
-              <div
-                className={`w-2.5 h-2.5 rounded-full transition-all ${
-                  isOnline
-                    ? "bg-green-500 animate-pulse shadow-[0_0_8px_rgba(34,197,94,0.6)]"
-                    : "bg-red-500 shadow-[0_0_8px_rgba(239,68,68,0.6)]"
-                }`}
-              ></div>
-            </div>
+            <div
+              className={`w-2.5 h-2.5 rounded-full transition-all ${
+                isOnline
+                  ? "bg-green-500 animate-pulse shadow-[0_0_8px_rgba(34,197,94,0.6)]"
+                  : "bg-red-500 shadow-[0_0_8px_rgba(239,68,68,0.6)]"
+              }`}
+              title={isOnline ? t("sync.connected") : t("sync.disconnected")}
+              aria-label={isOnline ? t("sync.connected") : t("sync.disconnected")}
+            />

Adding aria-label improves accessibility for screen readers, as the visual indicator has no text content.

hooks/useCalendarSubscriptions.ts (1)

270-281: Consider removing unused _calendarName parameter or using it for consistency.

The dismiss function accepts _calendarName but ignores it (with an eslint-disable). While the current implementation works by looking up the name from the cache, this creates an inconsistent API compared to subscribe which actually uses the name.

Either remove the parameter if callers don't need it, or pass it through mutation variables like subscribe does for symmetry.

♻️ Option: Use the name parameter like subscribe

   const dismissMutation = useMutation({
-    mutationFn: dismissApi,
-    onMutate: async (calendarId) => {
+    mutationFn: (variables: { calendarId: string; name: string }) =>
+      dismissApi(variables.calendarId),
+    onMutate: async (variables) => {
+      const { calendarId } = variables;
       // ... rest of onMutate
     },
-    onSuccess: (_, calendarId) => {
-      const data = queryClient.getQueryData<SubscriptionResponse>(
-        queryKeys.subscriptions.all
-      );
-      const calendar =
-        data?.available.find((cal) => cal.id === calendarId) ||
-        data?.dismissed.find((cal) => cal.id === calendarId);
+    onSuccess: (_, variables) => {
       toast.success(
-        t("calendar.unsubscribeSuccess", { name: calendar?.name || "Calendar" })
+        t("calendar.unsubscribeSuccess", { name: variables.name || "Calendar" })
       );
     },

Then update the wrapper:

     dismiss: async (
       calendarId: string,
-      // eslint-disable-next-line `@typescript-eslint/no-unused-vars`
-      _calendarName: string
+      calendarName: string
     ): Promise<boolean> => {
       try {
-        await dismissMutation.mutateAsync(calendarId);
+        await dismissMutation.mutateAsync({ calendarId, name: calendarName });
         return true;

hooks/useShiftActions.ts (2)

30-49: Consider if duplicate error logging is intentional.

Both handleShiftSubmit and handleDeleteShift log errors, but the underlying createShift and deleteShift from useShifts already log errors and show toast notifications. This results in duplicate console.error output.

If the additional logging is intentional for debugging call-site context, consider adding distinguishing information. Otherwise, the try/catch can simply re-throw or be removed.

---

8-21: Remove unused onStatsRefresh prop.

The onStatsRefresh prop is defined in the interface but never destructured or used in the hook.

♻️ Remove unused prop

 interface UseShiftActionsProps {
   shifts: ShiftWithCalendar[];
   presets: ShiftPreset[];
   createShift: (data: ShiftFormData) => Promise<ShiftWithCalendar>;
   deleteShift: (id: string) => Promise<void>;
-  onStatsRefresh?: () => void;
 }

hooks/useCalendarTokens.ts (1)

56-66: Consider using parseErrorResponse in fetchTokensApi for consistent error messaging.
Right now this path always throws a generic HTTP status even when the API returns a useful error body.

🔧 Suggested tweak

   if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
+    const errorMessage = await parseErrorResponse(response);
+    throw new Error(errorMessage);
   }

hooks/useAdminAuditLogs.ts (1)

240-243: Use query key factory for cache invalidation consistency.

The invalidation uses a hardcoded ["admin", "audit-logs"] array while the query registration uses queryKeys.admin.auditLogs(). If the key structure in lib/query-keys.ts changes, this invalidation could silently break.

♻️ Suggested refactor using the query key factory

    onSettled: () => {
-      queryClient.invalidateQueries({ queryKey: ["admin", "audit-logs"] });
+      queryClient.invalidateQueries({ queryKey: queryKeys.admin.auditLogs() });
      queryClient.invalidateQueries({ queryKey: queryKeys.admin.stats });
    },

Apply the same change on line 260.

app/admin/logs/page.tsx (2)

209-216: Consider memoizing handleDebouncedSearchChange for safer debounce behavior.

The handleDebouncedSearchChange function is not in the dependency array, which could cause stale closure issues if the function body changes in future refactors. Since the function only calls stable state setters, it works correctly today.

♻️ Optional: Wrap handler with useCallback for explicit stability

+  const handleDebouncedSearchChange = useCallback((value: string) => {
+    setDebouncedSearch(value);
+    setPage(0);
+    setSelectedLogIds([]);
+    setExpandedRows(new Set());
+  }, []);

-  const handleDebouncedSearchChange = (value: string) => {
-    setDebouncedSearch(value);
-    setPage(0);
-    setSelectedLogIds([]);
-    setExpandedRows(new Set());
-  };

  // Debounce search query
  useEffect(() => {
    const timer = setTimeout(() => {
      handleDebouncedSearchChange(searchQuery);
    }, 500);

    return () => clearTimeout(timer);
-  }, [searchQuery]);
+  }, [searchQuery, handleDebouncedSearchChange]);

---

578-582: Redundant Date conversion.

The useAdminAuditLogs hook already converts log.timestamp to a Date object (see hooks/useAdminAuditLogs.ts line 101). Wrapping it again with new Date() is unnecessary.

♻️ Simplified date formatting

                    <TableCell className="whitespace-nowrap">
-                      {format(new Date(log.timestamp), "PPp", {
+                      {format(log.timestamp, "PPp", {
                        locale: dateLocale,
                      })}
                    </TableCell>

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useSSEConnection` hook from `hooks/useSSEConnection.ts` for real-time sync connection management. The hook automatically handles reconnection, visibility changes, and triggers data refreshes.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*.{ts,tsx} : Implement data fetching hooks following the pattern: `useShifts`, `usePresets`, `useNotes`, `useCalendars` with accompanying action hooks like `useShiftActions`, `useNoteActions` for CRUD operations with optimistic updates.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : After any database mutation (create/update/delete), emit an SSE event using `eventEmitter.emit('calendar-change', {...})` with appropriate type and action to keep clients in sync.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useCalendarPermission(calendarId)` hook to check UI permissions, which returns `canEdit`, `canDelete`, `canShare`, and `permission` level for displaying conditional UI elements.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*.{ts,tsx} : Implement data fetching hooks following the pattern: `useShifts`, `usePresets`, `useNotes`, `useCalendars` with accompanying action hooks like `useShiftActions`, `useNoteActions` for CRUD operations with optimistic updates.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : Use `getUserCalendarPermission(userId, calendarId)` from `lib/auth/permissions.ts` to retrieve the exact permission level, which returns permission string or `null` if user has no access.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Always check permissions using `checkPermission(userId, calendarId, requiredLevel)` function from `lib/auth/permissions.ts` in both API routes and UI components before allowing mutations.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use Better Auth's built-in client methods (`authClient.listSessions()`, `authClient.revokeOtherSessions()`) for client-side session management. Never implement custom session revocation logic.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : For calendar permission hierarchy in SQL queries and permission checks, follow: `owner` (highest) > `admin` > `write` > `read` (lowest). Use `getUserAccessibleCalendars(userId)` to get all accessible calendars.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : For auth-related configuration checks, use the convenience hook `useAuthFeatures()` from `hooks/useAuthFeatures.ts` to access `isAuthEnabled`, `allowRegistration`, `allowGuest`, and `providers` on the client side.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useSSEConnection` hook from `hooks/useSSEConnection.ts` for real-time sync connection management. The hook automatically handles reconnection, visibility changes, and triggers data refreshes.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to components/**/*.{tsx,ts} : Components in `/components` directory should be `"use client"` by default for interactive UI, and should use shadcn/ui patterns with Radix UI primitives and Lucide icons.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*Actions.{ts,tsx} : Implement optimistic updates in action hooks by: generating temp ID (`temp-${Date.now()}`), adding item to state immediately, making API call, removing temp item on error with toast, replacing temp item on success.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: All user-facing strings must use the `t()` function from `next-intl` for translations. Never use hardcoded English strings in components or API responses.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/auth/**/*.ts : For Better Auth integration, use built-in methods for authentication operations (`login`, `logout`, `session management`, `OAuth`). Use custom code in `lib/auth/admin.ts` only for permission checks (`canEditUser`, `canDeleteUser`, `canBanUser`).

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : After any database mutation (create/update/delete), emit an SSE event using `eventEmitter.emit('calendar-change', {...})` with appropriate type and action to keep clients in sync.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Respect `shift.syncedFromExternal` flag - synced shifts from external calendars cannot be edited or deleted by users. Check this flag before allowing shift mutations.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to components/**/*sheet*.{tsx,ts} : Use the Sheet pattern (`components/ui/base-sheet.tsx`) for all forms with side panels, including unsaved changes confirmation via `useDirtyState` hook and consistent header/footer styling with gradient backgrounds.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: When auth is enabled, unauthenticated users (`userId = null`) can access calendars with `guestPermission != "none"`. Use `allowGuestAccess()` function to check if guest access feature is enabled.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to components/**/*dialog*.{tsx,ts} : Use the Dialog pattern (`components/ui/dialog.tsx` from shadcn/ui) for list views, confirmations, and read-only displays.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{ts,tsx} : Store and display dates as `YYYY-MM-DD` strings (local dates without timezone conversion). Use `formatDateToLocal()` from `lib/date-utils.ts` before saving to database and `date-fns` with locale from `getDateLocale()` for display.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `getDateLocale(locale)` from `lib/date-utils.ts` when formatting dates with `date-fns` to ensure proper locale-aware date display.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{ts,tsx} : Use `formatDateToLocal(date)` utility from `lib/date-utils.ts` to convert dates to `YYYY-MM-DD` format before saving to database.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to lib/db/schema.ts : Database schema modifications must be made in `lib/db/schema.ts`. After changes, generate migrations with `npm run db:generate`, review SQL in `drizzle/` folder, then apply with `npm run db:migrate`.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}

hooks/useCalendarTokens.ts (1)

57-67: Consider using parseErrorResponse for consistency.

Other API functions (createTokenApi, updateTokenApi, deleteTokenApi) use the parseErrorResponse helper, but fetchTokensApi throws a generic HTTP error. For consistency and better error messaging when fetches fail:

♻️ Suggested change

 async function fetchTokensApi(
   calendarId: string
 ): Promise<CalendarAccessToken[]> {
   const response = await fetch(`/api/calendars/${calendarId}/tokens`);

   if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
+    const errorMessage = await parseErrorResponse(response);
+    throw new Error(errorMessage);
   }

   return await response.json();
 }

hooks/useCalendars.ts (2)

231-241: Consider adding RateLimitError check for consistency.

If rate-limit handling is added to updateCalendarApi (as suggested above), the onError handler should also skip the toast for RateLimitError to match createMutation's behavior.

---

320-335: Consider consistent error handling across wrappers.

createCalendar catches errors and handles RateLimitError specifically, while updateCalendar and deleteCalendar let errors propagate to the caller. This is an asymmetric pattern.

If rate-limit handling is added to the update/delete API functions, these wrappers should follow the same pattern as createCalendar:

♻️ Proposed consistency fix

   const updateCalendar = async (
     calendarId: string,
     updates: {
       name?: string;
       color?: string;
       guestPermission?: "none" | "read" | "write";
     }
   ) => {
-    return updateMutation.mutateAsync({ calendarId, updates });
+    try {
+      await updateMutation.mutateAsync({ calendarId, updates });
+    } catch (error) {
+      if (error instanceof RateLimitError) {
+        await handleRateLimitError(error.response, t);
+      }
+    }
   };

   const deleteCalendar = async (calendarId: string) => {
-    return deleteMutation.mutateAsync(calendarId);
+    try {
+      await deleteMutation.mutateAsync(calendarId);
+    } catch (error) {
+      if (error instanceof RateLimitError) {
+        await handleRateLimitError(error.response, t);
+      }
+    }
   };

hooks/useCalendarSubscriptions.ts (2)

67-70: Minor: JSON parsing could fail on non-JSON error responses.

If the server returns a non-JSON error response (e.g., 500 with HTML), response.json() will throw before you can extract the error message.

♻️ Optional defensive improvement

   if (!response.ok) {
-    const error = await response.json();
-    throw new Error(error.error || "Failed to subscribe");
+    let message = "Failed to subscribe";
+    try {
+      const error = await response.json();
+      message = error.error || message;
+    } catch {
+      // Response wasn't JSON, use default message
+    }
+    throw new Error(message);
   }

---

272-276: The _calendarName parameter is used by callers and should not be removed without updating all call sites.

The dismiss method is called with two arguments in components/calendar-discovery-sheet.tsx (line 83): await dismiss(calendar.id, calendar.name). Removing the parameter would break this caller.

For consistency with the subscribe method (which accepts and uses calendarName), consider using the _calendarName parameter in the dismiss mutation for optimistic updates or other UI feedback, or document why the signature requires it despite not using the value internally.

hooks/useShifts.ts (1)

204-231: Consider moving mutations into a useShiftActions hook.
Keeping useShifts focused on reads aligns with the existing hook pattern and keeps concerns separated. As per coding guidelines, ...

hooks/useShiftStats.ts (1)

33-50: Consider passing React Query’s AbortSignal into fetch.
This enables request cancellation on unmount/refetch and avoids wasted work.

♻️ Suggested refactor

-async function fetchShiftStatsApi(
-  calendarId: string,
-  period: string,
-  currentDate: Date
-): Promise<ShiftStatsData> {
+async function fetchShiftStatsApi(
+  calendarId: string,
+  period: string,
+  currentDate: Date,
+  signal?: AbortSignal
+): Promise<ShiftStatsData> {
   const params = new URLSearchParams({
     calendarId,
     period,
     date: formatDateToLocal(currentDate),
   });

-  const response = await fetch(`/api/shifts/stats?${params}`);
+  const response = await fetch(`/api/shifts/stats?${params}`, { signal });

@@
-    queryFn: () => fetchShiftStatsApi(calendarId!, period, currentDate),
+    queryFn: ({ signal }) =>
+      fetchShiftStatsApi(calendarId!, period, currentDate, signal),

Also applies to: 78-86

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useSSEConnection` hook from `hooks/useSSEConnection.ts` for real-time sync connection management. The hook automatically handles reconnection, visibility changes, and triggers data refreshes.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*.{ts,tsx} : Implement data fetching hooks following the pattern: `useShifts`, `usePresets`, `useNotes`, `useCalendars` with accompanying action hooks like `useShiftActions`, `useNoteActions` for CRUD operations with optimistic updates.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : After any database mutation (create/update/delete), emit an SSE event using `eventEmitter.emit('calendar-change', {...})` with appropriate type and action to keep clients in sync.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*.{ts,tsx} : Implement data fetching hooks following the pattern: `useShifts`, `usePresets`, `useNotes`, `useCalendars` with accompanying action hooks like `useShiftActions`, `useNoteActions` for CRUD operations with optimistic updates.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useSSEConnection` hook from `hooks/useSSEConnection.ts` for real-time sync connection management. The hook automatically handles reconnection, visibility changes, and triggers data refreshes.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: All user-facing strings must use the `t()` function from `next-intl` for translations. Never use hardcoded English strings in components or API responses.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : After any database mutation (create/update/delete), emit an SSE event using `eventEmitter.emit('calendar-change', {...})` with appropriate type and action to keep clients in sync.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useCalendarPermission(calendarId)` hook to check UI permissions, which returns `canEdit`, `canDelete`, `canShare`, and `permission` level for displaying conditional UI elements.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to lib/db/schema.ts : Database schema modifications must be made in `lib/db/schema.ts`. After changes, generate migrations with `npm run db:generate`, review SQL in `drizzle/` folder, then apply with `npm run db:migrate`.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : For calendar permission hierarchy in SQL queries and permission checks, follow: `owner` (highest) > `admin` > `write` > `read` (lowest). Use `getUserAccessibleCalendars(userId)` to get all accessible calendars.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `getDateLocale(locale)` from `lib/date-utils.ts` when formatting dates with `date-fns` to ensure proper locale-aware date display.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Respect `shift.syncedFromExternal` flag - synced shifts from external calendars cannot be edited or deleted by users. Check this flag before allowing shift mutations.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Always check permissions using `checkPermission(userId, calendarId, requiredLevel)` function from `lib/auth/permissions.ts` in both API routes and UI components before allowing mutations.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*Actions.{ts,tsx} : Implement optimistic updates in action hooks by: generating temp ID (`temp-${Date.now()}`), adding item to state immediately, making API call, removing temp item on error with toast, replacing temp item on success.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : Use `getUserCalendarPermission(userId, calendarId)` from `lib/auth/permissions.ts` to retrieve the exact permission level, which returns permission string or `null` if user has no access.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use Better Auth's built-in client methods (`authClient.listSessions()`, `authClient.revokeOtherSessions()`) for client-side session management. Never implement custom session revocation logic.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{ts,tsx} : Store and display dates as `YYYY-MM-DD` strings (local dates without timezone conversion). Use `formatDateToLocal()` from `lib/date-utils.ts` before saving to database and `date-fns` with locale from `getDateLocale()` for display.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{ts,tsx} : Use `formatDateToLocal(date)` utility from `lib/date-utils.ts` to convert dates to `YYYY-MM-DD` format before saving to database.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}

hooks/useActivityLogs.ts (2)

135-140: ESLint disable warrants attention.

The t function is used inside queryFn but excluded from the query key dependencies. While t is typically stable within a locale session, if the user's locale changes at runtime, the query won't automatically refetch with updated translations. If locale changes trigger a full remount, this is fine; otherwise, consider whether this edge case matters for your app.

---

147-147: Use the centralized query key factory for invalidation.

Line 136 uses queryKeys.activityLogs({ filters, pagination }), but line 147 uses the hardcoded ["activity-logs"]. While prefix-based invalidation works, using the factory is more consistent and maintainable.

♻️ Suggested fix

-      queryClient.invalidateQueries({ queryKey: ["activity-logs"] });
+      queryClient.invalidateQueries({ queryKey: queryKeys.activityLogs() });

hooks/useShiftStats.ts (1)

33-42: Reuse a single date key for query + request to avoid drift.

Computing the formatted date once avoids any mismatch if currentDate mutates between render and fetch, and eliminates duplicate formatting.

♻️ Suggested refactor

-async function fetchShiftStatsApi(
-  calendarId: string,
-  period: string,
-  currentDate: Date
-): Promise<ShiftStatsData> {
-  const params = new URLSearchParams({
-    calendarId,
-    period,
-    date: formatDateToLocal(currentDate),
-  });
+async function fetchShiftStatsApi(
+  calendarId: string,
+  period: string,
+  dateKey: string
+): Promise<ShiftStatsData> {
+  const params = new URLSearchParams({
+    calendarId,
+    period,
+    date: dateKey,
+  });
@@
 export function useShiftStats({
   calendarId,
   currentDate,
   period,
 }: UseShiftStatsOptions) {
+  const dateKey = formatDateToLocal(currentDate);
   const {
     data: stats = null,
     isLoading: loading,
     refetch,
   } = useQuery({
     queryKey: queryKeys.stats.shifts(
       calendarId!,
       period,
-      formatDateToLocal(currentDate)
+      dateKey
     ),
-    queryFn: () => fetchShiftStatsApi(calendarId!, period, currentDate),
+    queryFn: () => fetchShiftStatsApi(calendarId!, period, dateKey),
     enabled: !!calendarId,
     refetchInterval: REFETCH_INTERVAL,
   });

Please verify this aligns with your React Query v5 query-key and request parameter conventions.

Also applies to: 74-93

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useSSEConnection` hook from `hooks/useSSEConnection.ts` for real-time sync connection management. The hook automatically handles reconnection, visibility changes, and triggers data refreshes.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : After any database mutation (create/update/delete), emit an SSE event using `eventEmitter.emit('calendar-change', {...})` with appropriate type and action to keep clients in sync.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*.{ts,tsx} : Implement data fetching hooks following the pattern: `useShifts`, `usePresets`, `useNotes`, `useCalendars` with accompanying action hooks like `useShiftActions`, `useNoteActions` for CRUD operations with optimistic updates.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useSSEConnection` hook from `hooks/useSSEConnection.ts` for real-time sync connection management. The hook automatically handles reconnection, visibility changes, and triggers data refreshes.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{ts,tsx} : Store and display dates as `YYYY-MM-DD` strings (local dates without timezone conversion). Use `formatDateToLocal()` from `lib/date-utils.ts` before saving to database and `date-fns` with locale from `getDateLocale()` for display.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `getDateLocale(locale)` from `lib/date-utils.ts` when formatting dates with `date-fns` to ensure proper locale-aware date display.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{ts,tsx} : Use `formatDateToLocal(date)` utility from `lib/date-utils.ts` to convert dates to `YYYY-MM-DD` format before saving to database.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to **/*.{tsx} : Use `useCalendarPermission(calendarId)` hook to check UI permissions, which returns `canEdit`, `canDelete`, `canShare`, and `permission` level for displaying conditional UI elements.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to hooks/use*Actions.{ts,tsx} : Implement optimistic updates in action hooks by: generating temp ID (`temp-${Date.now()}`), adding item to state immediately, making API call, removing temp item on error with toast, replacing temp item on success.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: All user-facing strings must use the `t()` function from `next-intl` for translations. Never use hardcoded English strings in components or API responses.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Respect `shift.syncedFromExternal` flag - synced shifts from external calendars cannot be edited or deleted by users. Check this flag before allowing shift mutations.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Always check permissions using `checkPermission(userId, calendarId, requiredLevel)` function from `lib/auth/permissions.ts` in both API routes and UI components before allowing mutations.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : Use `getUserCalendarPermission(userId, calendarId)` from `lib/auth/permissions.ts` to retrieve the exact permission level, which returns permission string or `null` if user has no access.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : After any database mutation (create/update/delete), emit an SSE event using `eventEmitter.emit('calendar-change', {...})` with appropriate type and action to keep clients in sync.

Learnt from: CR
Repo: panteLx/BetterShift PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T02:03:48.622Z
Learning: Applies to app/api/**/*.ts : For calendar permission hierarchy in SQL queries and permission checks, follow: `owner` (highest) > `admin` > `write` > `read` (lowest). Use `getUserAccessibleCalendars(userId)` to get all accessible calendars.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}